ansaurus

Question

Wishing for Static Abstract functions in C#. Any work arounds?

Answer 1

+1 A:

It might not be an option for you, but C# 4.0 supports optional arguments with default values for methods, which removes the need to have multiple overloads in a lot of cases. For example:

public void ExampleMethod(int required, string optionalstr = "default string", int optionalint = 10)

You could call the above method with ExampleMethod(1) or ExampleMethod(1, 'Test', 9).

tbreffni 2010-02-24 18:50:07

Yes, I am using C# 4.0, and plan on doing this. However, that see leaves me needing to copy/manipulate 2 functions (there are 2 differents overload there really) in close to 75 files. Plus more if I need to work with any other WMI classes... And I always hate having duplicate code anywhere, espicially in 75+ files :-\

TJMonk15 2010-02-24 18:52:13

Maybe you could use custom attributes and reflection to set and read the unique values per class? http://msdn.microsoft.com/en-us/library/z0w1kczw%28VS.100%29.aspx

tbreffni 2010-02-24 18:58:44

Will that work correctly in a static context from the base class?

TJMonk15 2010-02-24 19:03:12

Answer 2

+2 A:

Why not move these eight common functions into a separate class as instance methods, and initialize the instance with the three parameters that vary by class. Then you could aggregate and expose the instance of that helper class on each of the derived types. Since the static methods can't use any instance data, there's no reason to duplicate them.

Here's an example of what I mean:

public class WMIInstance
{
    private readonly string CreatedWmiNamespace = "root\\microsoftdns";
    private readonly string CreatedClassName = "MicrosoftDNS_AAAAType";
    private readonly System.Management.ManagementScope statMgmtScope = null;

    public WMIInstance( string namespace, string className, ManagementScope scope )
    { /*... initialize private members here... */

    public WMI.ManagementTypeCollection GetInstances( System.String[] selectedProperties )
    { return WMI.Object.GetInstances( ... ); }

    /* other overloads ... */
}

public class AAAAType : WMI.Object
{
    private static string CreatedWmiNamespace = "root\\microsoftdns";
    private static string CreatedClassName = "MicrosoftDNS_AAAAType";
    private static System.Management.ManagementScope statMgmtScope = null;

    private static readonly WMIInstances _instances = new WMIInstance( CreatedWmiNamespace, CreatedClassName, statMgmgtScope );

    public static WMIInstances Getter { get { return _instances; } }
}

LBushkin 2010-02-24 18:51:04

Explain... How would that allow me to have the code only in the base class? (Which is my desired result...) ?

TJMonk15 2010-02-24 18:54:38

I added an example. Basically, `AAAAType` gets a static members which provides access to the `GetInstances()` methods. These methods, then, in turn, become instance methods of the utility class `WMIInstance`. This way you instantiate `WMIInstance` for each derived WMI class and simply initialize it with the necessary parameters.

LBushkin 2010-02-24 18:59:41

Note that the methods of `WMIInstance` are NOT static, but the created instance of `WMIInstance` is a static members of `AAAAType`.

LBushkin 2010-02-24 19:00:38

While that would work, it is still a lot of duplicate code in every derived class. hmm...

TJMonk15 2010-02-24 19:02:41

There's much less duplication in the derived classes. You are moving all of the code into a shared class - and creating one instance of the shared class in each derived class. There's a little bit of code that goes into each class - but this is a necessary evil, since in C# you *don't* have anything like a virtual static method.

LBushkin 2010-02-24 19:07:04

Answer 3

A:

Maybe a small factory?

class Config { string ClassName; string Namespace; ManagementScope Scope; }

static class Factory {
     public static readonly Dictionary<Type, Config> Configs = new ...;

     static GetInstances(Type requestedType, ...) {
         var config = Configs[requestedType];
         // work with it...
     }
}

class AAAAType {
     static AAAAType{
          Factory.Configs.Add(typeof(AAAAType), new Config{ ... });
     }
}

It may not be perfect code, but I didn't want to go far from your initial proposal. Moreover, I don't really like it and would recommend a redesign of your idea, because of:

too much static
6 parameters to a method, including a function pointer Really?
System.String ? there could be other string-types so that you qualify it that strong?
a couple of usings at the top would help to avoid qualified names
getting intent of the code is not easy

2010-02-24 19:09:17

This is mostly Auto-Generated code from a Microsoft Tool ~rolls eyes~ yea, it doesn't make a lot of sense. I'm trying to clean it up, hence this question. :)

TJMonk15 2010-02-24 19:13:04

ansaurus

tags:

views:

answers:

Wishing for Static Abstract functions in C#. Any work arounds?

related questions