我有一个类，里面有近20个公共属性。这些属性都是字符串类型，并且它们填充了来自数据库不同表的数据。
除此之外，设置方法非常普通，而获取方法很特殊，因为我需要调用特定的方法。目前每个属性都需要这样做（见下文）。
我的问题是：是否有另一种更有效的方法来实现这一点，即不必手动定义每个公共属性？
class myclass
{
private string _Firstname;
private string _Lastname;
.....
public string Firstname
{
get {
return ModifyStringMethod(this._Firstname);
}
set {
this._Firstname = value;
}
}
}
如上所述，每个公共属性看起来都是相同的。get调用ModifyStringMethod并将私有成员作为参数传递，而set只是设置私有成员。
另一个选项与Dion V.的解决方案类似，但它利用隐式转换使属性在外部表现得像普通字符串，并使使用简单自动属性成为可能。但这仅在ModifyStringMethod是静态的并且不需要来自类外部的参数时才有效。
public struct EllipsisString
{
private string _value;
public string Value {get { return _value; }}
public EllipsisString(string value)
{
_value = value;
}
// implicit conversion from string so it is possible to just assign string to the property
public static implicit operator EllipsisString(string value)
{
return new EllipsisString(value);
}
public static implicit operator string(EllipsisString original)
{
return SpecialMethod(original.Value);
}
public override string ToString()
{
return SpecialMethod(Value);
}
private static string SpecialMethod(string value)
{
return value + "...";
}
}
使用方法很简单：
private EllipsisString FirstName { get; set; }
public void Method()
{
FirstName = "Thomas";
Console.WriteLine(FirstName);
Console.WriteLine(FirstName.Value);
}
PostSharp是另一种选择。
你只需在类上应用一个属性，并使用“get; set;”语法编写属性。
PostSharp是一个.NET工具，使开发人员能够将代码方面应用于它们的程序集、命名空间、类或方法。
具体来说，PostSharp使开发人员通过将属性应用于代码块来编写更少的代码，稍后将具有该方面的代码反映进入并与所选代码块一起执行。这种方法显着减少了在代码库中冗余的“管道”。
常见用例包括以下内容：
日志记录
安全性
撤消/重做
INotifyPropertyChanged
异常处理
public class ModifyStringMethodInterceptor : IInterceptor
{
public void Intercept(IInvocation invocation)
{
invocation.Proceed();
if (invocation.Method.Name.StartsWith("get_") &&
invocation.Method.ReturnType == typeof(string))
{
invocation.ReturnValue =
ModifyStringMethod((string)invocation.ReturnValue);
}
}
private static string ModifyStringMethod(string input)
{
return (input ?? "") + "MODIFIED";
}
}
if (invocation.Method.Name.StartsWith("get_") &&
invocation.Method.ReturnType == typeof(string))
invocation.ReturnValue = ModifyStringMethod((string)invocation.ReturnValue);
3）使用虚方法定义您希望添加此行为的对象（请注意，我也可以在此处使用自动实现属性）奖励
public class Intercepted
{
public virtual string A { get; set; }
}
4) 接下来使用DynamicProxy中的ProxyGenerator类创建对象实例，
例如：
public class Program
{
static void Main(string[] args)
{
var pg = new ProxyGenerator();
// Intercepted will be an instance of Intercepted class with the
// ModifyStringMethodInterceptor applied to it
var intercepted = pg.CreateClassProxy<Intercepted>(new ModifyStringMethodInterceptor());
intercepted.A = "Set ... ";
Console.WriteLine(intercepted.A);
Console.ReadLine();
}
}
输出结果为：
Set ... MODIFIED
[AttributeUsage(AttributeTargets.Method)]
public class ModifyStringMethodAttribute : Attribute
{
}
然后定义对象为：
public class Intercepted
{
public virtual string A { [ModifyStringMethod] get; set; }
}
并且拦截器的修改：
if (invocation.Method.ReturnType == typeof(string) &&
invocation.Method.GetCustomAttributes(true)
.OfType<ModifyStringMethodAttribute>().Any())
{
invocation.ReturnValue =
ModifyStringMethod((string)invocation.ReturnValue);
}
检查属性，然后应用方法调用。
class MyClass
{
private IDictionary<string, string> propertyValueByName = new Dictionary<string, string>();
public string this[string propertyName]
{
get { return propertyValueByName[propertyName]; }
set { propertyValueByName[propertyName] = ModifyStringMethod(value); }
}
public string FirstName
{
get { return this["FirstName"]; }
set { this["FirstName"] = value; }
}
public string LastName
{
get { return this["LastName"]; }
set { this["LastName"] = value; }
}
}
class MyClass
{
public string FirstName { private get; set; }
public string LastName { private get; set; }
public string GetModifiedValue(string propertyName)
{
var prop = this.GetType().GetProperty(propertyName);
return ModifyStringMethod((string)prop.GetValue(this, null));
}
}
所以，为了获取每个修改后的值，而不是使用 MyClass.FirstName，你应该使用 MyClass.GetModifiedValue("FirstName")
<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
<Header>
<Title>propnot</Title>
<Shortcut>propnot</Shortcut>
<Description>Code snippet for property and backing field with property change event</Description>
<Author>Radin Gospodinov</Author>
<SnippetTypes>
<SnippetType>Expansion</SnippetType>
</SnippetTypes>
</Header>
<Snippet>
<Declarations>
<Literal>
<ID>type</ID>
<ToolTip>Property type</ToolTip>
<Default>int</Default>
</Literal>
<Literal>
<ID>property</ID>
<ToolTip>Property name</ToolTip>
<Default>MyProperty</Default>
</Literal>
<Literal>
<ID>field</ID>
<ToolTip>The variable backing this property</ToolTip>
<Default>myVar</Default>
</Literal>
</Declarations>
<Code Language="csharp">
<![CDATA[private $type$ $field$;
public $type$ $property$
{
get { return this.$field$;}
set {
if(this.$field$ != value) {
$field$ = value;
this.RaisePropertyChanged(() => this.$property$);
}
}
}
$end$]]>
</Code>
</Snippet>
</CodeSnippet>
</CodeSnippets>
X.FirstName = "Some random long name";
Assert.AreEqual("Some random long name", X.FirstName);
根据您的评论，使用您的类设计可能无法正常工作（取决于在ModifyStringMethod中截断长度，实际上您可能会得到X.FireName ==“Some rand ...”。这似乎是错误的。
更好的方法可能是在属性行为之外实现修改，可能是通过扩展方法。所以像这样：
public static class FormatStringExtensions {
public static string ModifyStringForOutput(this string me) {
if (me.Length > 10) {
return me.Substring(0, 10) + "...";
}
return me;
}
};
这将使您能够使用自动属性定义数据类：
public class myclass {
public string FirstName { get; set; }
public string LastName {get; set; }
};
然后，使用扩展方法根据需要从属性中修改字符串值：
var instance = new myclass();
instance.FirstName = "01234567890123";
Console.WriteLine("Original Name {0}\nModified Name {1}\n",
instance.FirstName,
instance.FirstName.ModifyStringForOutput());
public class MyExpando : DynamicObject
{
Dictionary<string, object> dictionary = new Dictionary<string, object>();
//Want to create properties on initialization? Do it in the constructor
public MyExpando()
{
dictionary.Add("PreferredName", "Darth Sidious");
dictionary.Add("GreatDialog", "Something, something, darkside!");
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
bool success = dictionary.TryGetValue(binder.Name, out result);
if (success)
result = ModifiedValue(result);
return success;
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
dictionary[binder.Name] = value;
return true;
}
private string ModifiedValue(object val)
{
//Modify your string here.
if (val.ToString() != "Darth Sidious")
return "Something something complete";
return val.ToString();
}
}
dynamic x = new MyExpando();
x.FirstName = "Sheev";
x.LastName = "Palpatine"
Console.WriteLine(x.PreferredName + " says : \"" + x.GreatDialog + "\"");
Console.ReadKey();
public override bool TrySetMember(SetMemberBinder binder, object value)
{
if (!dictionary.ContainsKey(binder.Name))
return false;
dictionary[binder.Name] = value;
return true;
}
GetPropertyValue(string propertyName)。 - ste-fuMyClass具有读/写属性，而MyClassFacade具有只读属性，用于公开修改后的MyClass属性以供显示。 - Dan J