c#.net：使用初始化时应重写的方法扩展现有类

这样可能吗

假设我有一门弦乐课。我想添加一个方法

doString gcalc（）

。现在我想要一个类，它保存所有这些特殊字符串并对所有字符串调用

DoStringCalc（）

。但是在

DoStringCalc（）

中，每个字符串都可以有不同的逻辑，并且可以有数千个

对我来说（来自java）最合理的做法是在初始化新字符串时重写方法

DoStringCalc（）

。e、 g:

String hello = new String() {
    public override DoStringCalc() {
        //do something here
    }
}

这在C#中是如何解决的？

如果我理解正确，这就是您要寻找的

创建一个需要方法

DoStringCalc（）

的接口。然后让所有字符串类继承接口并实现它们的

DoStringCalc（）

方法。之后，您可以使用强类型列表

List

，该列表允许任何字符串类的实例，并从中调用它们各自的

DoStringCalc（）

创建一个需要方法
DoStringCalc（）
的接口。然后让所有字符串类继承接口并实现它们的
DoStringCalc（）
方法。在此之后，您可以使用强类型列表<代码>列表>代码>，允许任何字符串类的实例，并从中调用它们各自的<代码> doString Calc（）/<代码>。< /P> < P>如果您有许多不同的计算逻辑，请考虑将转换函数传递给类。包装将由类处理的值，并在同一类中存储适当的转换：

public class Foo
{
    public string Value;
    private Func<string, string> doStringCalc;

    public Foo(string value, Func<string, string> doStringCalc)
    {
        this.Value = value;
        this.doStringCalc = doStringCalc;
    }

    public void ExecuteTransform()
    {
        this.Value = this.doStringCalc(this.Value);
    }
}

如果您有许多不同的计算逻辑，请考虑将转换函数传递给类。包装将由类处理的值，并在同一类中存储适当的转换：
public class Foo
{
    public string Value;
    private Func<string, string> doStringCalc;

    public Foo(string value, Func<string, string> doStringCalc)
    {
        this.Value = value;
        this.doStringCalc = doStringCalc;
    }

    public void ExecuteTransform()
    {
        this.Value = this.doStringCalc(this.Value);
    }
}

一个选项是将
操作
作为类构造函数的一部分传递（如果要返回值，则传递
Func
）。例如：

public class MyThing
{
    private Action<MyThing> _doCalc { get; set; }

    public MyThing(Action<MyThing> doCalc)
    {
        _doCalc = doCalc;

    }

    public void DoCalc()
    {
        _doCalc(this);
    }

    public string SomeString { get; set; }
}

public class Wrapper<T>
{
    private Action<T> _doCalc { get; set; }

    public Wrapper(Action<T> doCalc)
    {
        _doCalc = doCalc;
    }

    public T Value { get; set; }

    public void DoCalc()
    {
        _doCalc(this.Value);
    }
}

另一种变体是创建通用包装类，例如：

public class MyThing
{
    private Action<MyThing> _doCalc { get; set; }

    public MyThing(Action<MyThing> doCalc)
    {
        _doCalc = doCalc;

    }

    public void DoCalc()
    {
        _doCalc(this);
    }

    public string SomeString { get; set; }
}

public class Wrapper<T>
{
    private Action<T> _doCalc { get; set; }

    public Wrapper(Action<T> doCalc)
    {
        _doCalc = doCalc;
    }

    public T Value { get; set; }

    public void DoCalc()
    {
        _doCalc(this.Value);
    }
}

公共类包装器
{
私有操作_doCalc{get；set；}
公共包装器（Action doCalc）
{
_doCalc=doCalc；
}
公共T值{get；set；}
公共文件
{
_doCalc（该值）；
}
}

现在你可以这样做了：

var stringWrapper = new Wrapper<string>(t => Console.WriteLine("string wrapper"));
var intWrapper = new Wrapper<int>(t => Console.WriteLine("int wrapper"));

stringWrapper.DoCalc();
intWrapper.DoCalc();

var-stringWrapper=new-Wrapper（t=>Console.WriteLine（“字符串包装”）；
var intWrapper=new Wrapper（t=>Console.WriteLine（“int Wrapper”）；
stringWrapper.DoCalc（）；
intWrapper.DoCalc（）；
一个选项是将
操作作为类构造函数的一部分传入（如果要返回值，则传入
Func
）。例如：

public class MyThing
{
    private Action<MyThing> _doCalc { get; set; }

    public MyThing(Action<MyThing> doCalc)
    {
        _doCalc = doCalc;

    }

    public void DoCalc()
    {
        _doCalc(this);
    }

    public string SomeString { get; set; }
}

public class Wrapper<T>
{
    private Action<T> _doCalc { get; set; }

    public Wrapper(Action<T> doCalc)
    {
        _doCalc = doCalc;
    }

    public T Value { get; set; }

    public void DoCalc()
    {
        _doCalc(this.Value);
    }
}

另一种变体是创建通用包装类，例如：

public class MyThing
{
    private Action<MyThing> _doCalc { get; set; }

    public MyThing(Action<MyThing> doCalc)
    {
        _doCalc = doCalc;

    }

    public void DoCalc()
    {
        _doCalc(this);
    }

    public string SomeString { get; set; }
}

public class Wrapper<T>
{
    private Action<T> _doCalc { get; set; }

    public Wrapper(Action<T> doCalc)
    {
        _doCalc = doCalc;
    }

    public T Value { get; set; }

    public void DoCalc()
    {
        _doCalc(this.Value);
    }
}

公共类包装器
{
私有操作_doCalc{get；set；}
公共包装器（Action doCalc）
{
_doCalc=doCalc；
}
公共T值{get；set；}
公共文件
{
_doCalc（该值）；
}
}

现在你可以这样做了：

var stringWrapper = new Wrapper<string>(t => Console.WriteLine("string wrapper"));
var intWrapper = new Wrapper<int>(t => Console.WriteLine("int wrapper"));

stringWrapper.DoCalc();
intWrapper.DoCalc();

var-stringWrapper=new-Wrapper（t=>Console.WriteLine（“字符串包装”）；
var intWrapper=new Wrapper（t=>Console.WriteLine（“int Wrapper”）；
stringWrapper.DoCalc（）；
intWrapper.DoCalc（）；
据我所知，如果您不拥有源代码，则无法更改类。例如，网络课程

您可以使用Extensionmethods扩展现有类：

public static classe StringExtension
{
    public static void DoStingCalc(this string str)
    {
         //Do your Stuff here
    }
}

如果要强制使用特定的方法。您必须从类中派生并用您希望确保的接口装饰它。或者做一个抽象的方法声明。
据我所知，不可能更改您不拥有源代码的类。例如，网络课程

您可以使用Extensionmethods扩展现有类：

public static classe StringExtension
{
    public static void DoStingCalc(this string str)
    {
         //Do your Stuff here
    }
}

如果要强制使用特定的方法。您必须从类中派生并用您希望确保的接口装饰它。或者做一个抽象的方法声明。
如何让一个不是我创建的类从一个新接口继承？e、 g.String、Integer等@Thypari:“假设我有String类，我想添加一个方法doString（）”你是如何向
System.String
或
System.Int32
添加方法的？你没有提到这些都是.NET类，我不太确定我会怎么做。可能使用一个以Func为参数的扩展方法？如何使一个不是由我创建的类从一个新接口继承？e、 g.String、Integer等@Thypari:“假设我有String类，我想添加一个方法doString（）”你是如何向
System.String
或
System.Int32
添加方法的？你没有提到这些都是.NET类，我不太确定我会怎么做。可能使用以Func为参数的扩展方法？在C#中不能像这样扩展类。你可以做一些奇怪的事情来破解它，但是把一个动作传入类构造函数怎么样？这个动作听起来不错。你能用我的例子举个小例子吗？然后我可以将你的帖子标记为答案。你不能在C#中扩展这样的类。你可以做一些奇怪的事情来破解它，但是把一个动作传入类构造函数怎么样？这个动作听起来不错。你能用我的例子举个小例子吗？然后我可以将你的帖子标记为答案。别忘了我要扩展的类是一个.net类。这还可能吗？我可以让类扩展字符串吗？你不能扩展
字符串
，这些类对你来说是禁止的-它们也应该是。用另一个变体更新，一个通用类，它可以包装你希望的任何类型，仍然需要
操作
，谢谢！这帮我找到了解决问题的正确方法！别忘了我要扩展的类是一个.net类。还是这样吗