How to access this static variable

  • Thread starter Thread starter LamSoft
  • Start date Start date
L

LamSoft

Class B { public B() {} }


Class A : B {
public static string ABC = "myABC";
public A() {}
}



main Program:

B myObject = new A();


and now is it possible to access "ABC" through "myObject" without modifying
the source code in Class A and Class B.

Thanks
 
Class B { public B() {} }
Class A : B {
public static string ABC = "myABC";
public A() {}
}
main Program:

B myObject = new A();

and now is it possible to access "ABC" through "myObject" without
modifying the source code in Class A and Class B.

Thanks
Click to expand...


As it's a static variable (in type A), you can only access it through the
Type A:
A.ABC, not through an instance.

Type B doesn't know anything about things declared in derived types (like A),
so your myObject (which is "just a B") doesn't know anything about that ABC.

*if* B declares a (virtual) method:
public virtual string MyMethod() { return "nil"; }
and A overrides it:
public override string MyMethod() { return A.ABC; }
then your myObject can still access the contents of ABC, using this MyMethod()

Hans Kesting
 
But there are not only 1 static variable in Class A, .... i don't wanna make
every function for each static variable
 
You may want to explain what you are trying to do so that we can understand
why not using A.ABC is not something that fit your needs and why accessing
static members through an instance member would make sense. It could raise
alternate approach to the problem you are trying to solve..
 
I am trying to make a language file and put all Static variables into each
different cs.
For example:


Class english : language{
public static string TEST = "test";
}

Class chinese : language {
public static string TEST = "´ú¸Õ";
}

Class language {}




and now i wanna access the TEST variable, but according to which language is
being selected ..

and I expected the following and something like that...

Language myLanguage = new english();
myLanguage.TEST // output will be "test"

Language myLanguage = new chinese();
myLanguage.TEST // output will be "´ú¸Õ"


Thank you very much.
 
Static members aren't what you want here. Read-only properties sound like a
better approach. You could try something like this (not tested):

public interface ILanguage
{
string Test { get; }
}

public class English : ILanguage
{
public string Test
{
get { return "test"; }
}
}

public class French : ILanguage
{
public string Test
{
get { return "le test"; }
}
}

A different approach might be:

public class Localization
{
private Dictionary<string, string> Strings;

static Localization(string lang)
{
// Load appropriate data into this.Strings from XML, SQL, etc.
}
}

You could then provide an indexer to access the values as follows:

Localization loc = new Localization("en");
loc["test"] // output would be "test"
 
As it's a static variable (in type A), you can only access it through the
Type A:
A.ABC, not through an instance.

Type B doesn't know anything about things declared in derived types (like A),
so your myObject (which is "just a B") doesn't know anything about that ABC.

*if* B declares a (virtual) method:
public virtual string MyMethod() { return "nil"; }
and A overrides it:
public override string MyMethod() { return A.ABC; }
then your myObject can still access the contents of ABC, using this MyMethod()

Hans Kesting
Click to expand...

Hi...

What is the utility of access a variable via a method when you have
direct access to that variable...
but still Hans provided a very good way to access static variable
through a method...

Masudur
 
First, have you looked at localization capabilities offered by the.NET
framework ?

If you want to access those members through an instance variable, why making
them static ? (I'm not sure but I see nowhere that you would really declare
them static on purpose ?).
Another option is to make them static but to have a single class and provide
the language they should provide. Remember that being a static member you
can stuff whatever you want (ie. your labels could come from any data
structure filled with strings for each supported language).

Or drop the static keyword and have your classes inherits and overrides your
default language class (could be abstract or an interface to make sure you
provide the appropriate text for each class).

For now it llklks like the code would direct to choose a design while you
choosed anothe design for the declarations. You have to match both aspects
(and have a llok at localization features if not already done).
 
As it's a static variable (in type A), you can only access it through
the
Type A:
A.ABC, not through an instance.
Type B doesn't know anything about things declared in derived types
(like A), so your myObject (which is "just a B") doesn't know
anything about that ABC.

*if* B declares a (virtual) method:
public virtual string MyMethod() { return "nil"; }
and A overrides it:
public override string MyMethod() { return A.ABC; }
then your myObject can still access the contents of ABC, using this
MyMethod()
Hans Kesting
Click to expand...
Hi...

What is the utility of access a variable via a method when you have
direct access to that variable...
but still Hans provided a very good way to access static variable
through a method...
Masudur
[/QUOTE]


Not much use, granted. But if you really want to have a static variable
that you still want to be able to access through an instance of an inherited
class, you need tricks like these.

Hans Kestin
 
Static members aren't what you want here. Read-only properties sound like a
better approach. You could try something like this (not tested):

public interface ILanguage
{
string Test { get; }
}

public class English : ILanguage
{
public string Test
{
get { return "test"; }
}
}

public class French : ILanguage
{
public string Test
{
get { return "le test"; }
}
}

A different approach might be:

public class Localization
{
private Dictionary<string, string> Strings;

static Localization(string lang)
{
// Load appropriate data into this.Strings from XML, SQL, etc.
}
}

You could then provide an indexer to access the values as follows:

Localization loc = new Localization("en");
loc["test"] // output would be "test"
 
Back
Top