0

My understanding is any method which does not modify state of the constaining class is a prime candidate to be made static because it does not touch the instance. An instance would be that containing class's data (fields/properties) so if I had a person class with a property called Name (and just that one property), and I am not modifying that property then my class can be set as static, but of course, but the function could be working with another object. Is this the right thing to look for when checking if a method should be made static?

Static variables are described as global variables, but what is the difference of this to any publicly variable? All the variables are in the server's memory and will be lost in a reboot etc. And then use this variable to hold expensive-to-get data (eg running stored procedures in a loop etc).

Thanks

Improve this question

5 Answers 5

Reset to default
3

My understanding is any method which does not modify state of the constaining class is a prime candidate to be made static because it does not touch the instance.

I wouldn't say it's a prime candidate, but rather just a candidate. Personally, I think methods should be made static if the API would suggest that it should be static from a logical, algorithmic standpoint. Technically, any method which doesn't change state can be static, but I don't believe it necessarily should be static.

and I am not modifying that property then my class can be set as static, but of course, but the function could be working with another object.

You can only set your class as static in C# if it has absolutely no instance variables. "Instances" of a static class don't exist (and cannot exist), nor can non-static members.

Now - for what I think you're really after...

The difference between a static variable and a non-static variable has to do with how it's accessed. When you define a static field on a class, you're defining a field that will always have a single instance (instance of the field) tied to the class itself. When you define a non-static, normal field, on the other hand, you will potentially have many instances of your field, each residing within one instance of your class.

This is why static variables are often described as global - anything that has access to the class has access to it's one copy of the static variable (provided its publicly accessible). However, non-static fields are different - you need to have a reference to the specific instance of the class in order to read or write to a non-static member.

.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

In C#, a static class can have static 'instance' variables
Yes, or course :) I was trying to talk about everything the OP mentioned.
2

My understanding is any method which does not modify state of the constaining [sic] class is a prime candidate to be made static because it does not touch the instance.

I don't think this is the right way to think of static vs. non-static. Rather, any method which is not related to the state of a class instance can be static. A name is obviously associated with a particular person, so a Name field on a Person class should almost certainly not be static. Otherwise, you could end up with a scenario like this:

public class Person {
    public static string Name { get; set; }

    public Person(string name) { Name = name; }

    public override string ToString() {
        return Name;
    }
}

Person dan = new Person("Dan";
Person john = new Person("John";

// outputs "John"
Console.WriteLine(john);

// outputs "John" again, since Dan doesn't have a name property all his own
// (and neither does John, for that matter)
Console.WriteLine(dan);

EDIT: Now, suppose we have a property such as House which can belong to not one but several people. blade asks: "How would this be modeled in code - static?"

My answer: NO, for the same reason already mentioned above. Suppose I've fixed the problem above by making the Name property non-static. Then I introduce a new static House property. Now I have a situation like this:

public class Person {
    public string Name { get; set; }
    public static House House { get; set; }

    public Person(string name, House house) {
        Name = name;
        House = house;
    }

    public override string ToString() {
        return String.Concat(Name, ", ", House);
    }
}

public class House {
    public double SquareFootage { get; set; }

    public House(double sqft) { SquareFootage = sqft; }

    public override string ToString() {
        return String.Format("House - {0} sq. ft.", SquareFootage);
    }
}

House danAndKatsHouse = new House(1000.0);
House johnsHouse = new House(2000.0);

Person dan = new Person("Dan", danAndKatsHouse);

// outputs "Dan, House - 1000 sq. ft." as expected
Console.WriteLine(dan);

Person kat = new Person("Kat", danAndKatsHouse);

// outputs "Kat, House - 1000 sq. ft.", again as expected
Console.WriteLine(kat);

Person john = new Person("John", johnsHouse);

// outputs "John, House - 2000 sq. ft.", so far so good...
Console.WriteLine(john);

// but what's this? suddenly dan and kat's house has changed?
// outputs "Dan, House - 2000 sq. ft."
Console.WriteLine(dan);

There's a difference between multiple objects of one class sharing the same object and ALL objects of that class sharing the same object. In the latter case, a static property makes sense; otherwise, it does not.

There are a few ways off the top of my head to deal with this scenario. They are:

1. Make the House property non-static

It might seem strange, but you can always just make the House property non-static and you won't ever have to worry about the problem above. Furthermore, assuming you actually do assign the same House object to each Person who shares it, making a change to the House through one Person object will actually achieve the desired effect:

House danAndKatsHouse = new House(1000.0);

// (after making Person.House property non-static)
Person dan = new Person("Dan", danAndKatsHouse);
Person kat = new Person("Kat", danAndKatsHouse);

dan.House.SquareFootage = 1500.0;

// outputs "1500"
Console.WriteLine(kat.House.SquareFootage);

This could actually be a problem, however, if you accidentally assign the same House to two people with the intention of them actually having two different Houses:

House smallerHouse = new House(1000.0);
House biggerHouse = new House(2000.0);

Person dan = new Person("Dan", smallerHouse);
Person john = new Person("John", biggerHouse);
Person bill = new Person("Bill", smallerHouse);

bill.House.SquareFootage = 1250.0;

// yikes, Dan's house just changed...
Console.WriteLine(dan);

2. Use a database

The fact is that the notion of making a house a property of a person is somewhat a forced concept to begin with. A person may move out of their house, different people may move in, etc. Really a relationship exists between the two, which makes using a database an appropriate solution.

Using this approach, what you'd do is have a Persons table, a Houses table, and a third table (maybe PersonHouses) containing id pairs from the other two tables to represent, I guess, home ownership.

If you don't have a full-blown database at your disposal, you can achieve effectively the same result (in .NET) using a System.Data.DataSet and its collection of System.Data.DataTable objects in your code. However, in any scenario where you are translating rows of a database (or DataTable) to objects and then back again, you do need to be aware of impedence mismatch. Basically, whatever meticulous precautions you take in your code to encapsulate your data are out the window once that data is in the database, ready to be modified by anyone with sufficient permissions.

3. Use dictionaries

Another approach, similar to using a database but a bit more work (and I think some programmers who've gone the DataSet route shudder at the thought of this), is to use dictionaries to keep track of your Person and House objects. The quickest way to implement this approach would be to have a Dictionary<int, Person> and a Dictionary<int, House>, and assign each Person a HouseId property:

public class Person {
    public int Id { get; private set; }
    public string Name { get; set; }
    public int HouseId { get; set; }

    private static int LastIdValue { get; set; }
    private static Dictionary<int, Person> People { get; set; }

    static Person() {
        LastIdValue = 0;
        People = new Dictionary<int, Person>();
    }

    // make the constructor private to disallow direct instantiation
    private Person(int id, string name, int houseId) {
        Id = id;
        Name = name;
        HouseId = houseId;
    }

    // only permit construction through this function, which inserts
    // the new Person into the static dictionary before returning it
    static public Person NewPerson(string name, int houseId) {
        Person p = new Person(LastIdValue++, name, houseId);
        People.Add(p.Id, p);
        return p;
    }

    static public Person getPersonById(int id) {
        Person p = null;
        return People.TryGetValue(id, out p) ? p : null;
    }
}

public class House {
    public int Id { get; private set; }
    public int SquareFootage { get; set; }

    private static int LastIdValue { get; set; }
    private static Dictionary<int, House> Houses { get; set; }

    static House() {
        LastIdValue = 0;
        Houses = new Dictionary<int, House>();
    }

    // make the constructor private to disallow direct instantiation
    private House(int id, int sqft) {
        Id = id;
        SquareFootage = sqft;
    }

    // only permit construction through this function, which inserts
    // the new House into the static dictionary before returning it
    static public House NewHouse(int sqft) {
        House h = new House(LastIdValue++, sqft);
        Houses.Add(h.Id, h);
        return h;
    }

    static public House getHouseById(int id) {
        House h = null;
        return Houses.TryGetValue(id, out h) ? h : null;
    }
}

House firstHouse = House.NewHouse(1000.0);
House secondHouse = House.NewHouse(2000.0);

Person dan = Person.NewPerson("Dan", firstHouse.Id);
Person kat = Person.NewPerson("Kat", firstHouse.Id);
Person john = Person.NewPerson("John", secondHouse.Id);

House dansHouse = House.getHouseById(dan.HouseId);
House katsHouse = House.getHouseById(kat.HouseId);

// this prints
if (katsHouse == dansHouse) { Console.WriteLine("Dan and Kat live in the same house."); }

// this also prints
if (dansHouse == firstHouse) { Console.WriteLine("Dan and Kat live in the first house."); }

// this does not print
if (dansHouse == secondHouse) { Console.WriteLine("Dan and Kat live in the second house."); }

This way, all your data encapsulation still holds. However, if you ever need your data to persist between instances of your code running, then you need to serialize your dictionaries in some file format (most likely XML), which could then be edited by anyone with sufficient privileges, and then you're back to the impedence mismatch problem of using a database all over again.

In light of the advantages and disadvantages of each approach, I think what actually makes the most sense -- and makes your life easiest -- is to simply make House a non-static property. This is assuming you don't have tons and tons of Person and House objects to keep track of.

Improve this answer

3 Comments

you should add the "public static string Name;" to the Person class for clarity. Since this is not common I read this three times and was sure that it is exactly the other way round
Good explanation. Something like a house may not be associated to a certain person but to several people. How would this be modelled in code - static?:
@blade: See my edit. I got rather carried away and gave you probably a whole lot more than you needed. But at least now you can't say nobody told you ;)
1

" if I had a person class with a property called Name (and just that one property), and I am not modifying that property then my class can be set as static"

That is not correct. A person class is almost certainly a domain entity. It is conceivable you might want to have a static method on a Person entity, but I haven't ever come across one. In your example, you would have a private setter for your 'Name' property.

The static-ness of anything should model your domain, rather than being a language implementaion detail.

Improve this answer

1 Comment

A static field could be something which applies to all person objects I guess, then. For example, if all person objects had the same house.
0

There are no true globl variables in C#, in the sense that that term is used in other languages like C. The difference between a static object and a global object is that a static object has permissions that are relative to the class in which it is defined. This is a very good thing, because you can create private static members that are only accessible to member of one class. The big problem with the abuse of global variables is the many depenencies to a single global variable that can evolve across a large colleciton of modules. Private static object avoid this problem.

One big problem with static objects is that they are not thread safe. In order to declare a thread safe static object, you must use the ThreadStatic attribute and provide a way for the object to be initialized on first access. You should do this for all multi-threaded environents e.g. ASP.NET, and any general purpose library that might run in multi-threaded environment. Heck, just always do this and you won't be sorry!

Improve this answer

2 Comments

While thread safety is a prime consideration for static members, there are other ways to achieve this than using the ThreadStatic attribute. This is a large topic, and there are few pat answers.
Good point. In fact, if you want a true singleton then ThreadStatic would get in the way. The thought was that ThreadStatic is among the simplest ways to acheive thread safety. It sounds like we both agree that this is important; given the general nature of the question, and think is should be noted that a plan for thread saftey is strongly advised.
0

If you have a Person class with a static field name:

public class Person {
    public static string Name { get; set; }
}

then you can only ever have one name. You can not have a list of persons with different names. Static can be seen as "Unique" in the way that it's value is global. This can be a trap in ASP.net applications by the way, because static applies through the entire application, which means to all users.

Static variables are rather rare and used for data that is really not part of a specific instance of the class. Or to return specific instances.

For example, Guid.Empty is a static field that returns a Guid that has all Bits set to 0.

A good example is System.Drawing.Color. Color has instance-specific variables, for example R,G,B and Alpha, but you have static fields like Color.Black which returns a Black color.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.