studio - se esperaba un descriptor de acceso get o set c#

Usando las propiedades típicas get set en C#... con parámetros

Question

Me gustaría hacer lo mismo en C #. ¿Hay alguna forma de usar propiedades en C # con parámetros de la misma manera que lo he hecho con el parámetro ''Clave'' en este ejemplo de VB.NET?

Private Shared m_Dictionary As IDictionary(Of String, Object) = New Dictionary(Of String, Object)

Public Shared Property DictionaryElement(ByVal Key As String) As Object
Get
If m_Dictionary.ContainsKey(Key) Then
Return m_Dictionary(Key)
Else
Return [String].Empty
End If
End Get
Set(ByVal value As Object)
If m_Dictionary.ContainsKey(Key) Then
m_Dictionary(Key) = value
Else
m_Dictionary.Add(Key, value)
End If
End Set
End Property

Gracias

Answer 1

¿Hay alguna forma de usar propiedades en C # con parámetros?

No. Solo puede proporcionar la propiedad predeterminada en C # con un argumento, para modelar el acceso indexado (como en un diccionario):

public T this[string key] {
get { return m_Dictionary[key]; }
set { m_Dictionary[key] = value; }
}

Otras propiedades no pueden tener argumentos. Use una función en su lugar. Por cierto, se recomienda hacer lo mismo en VB para que otros lenguajes de .NET (C # ...) puedan usar su código.

Por cierto, tu código es innecesariamente complicado. Cuatro cosas:

• No necesita escapar del identificador String . Usa la palabra clave directamente
• ¿Por qué no usar "" ?
• Use TryGetValue , es más rápido. Usted consulta el diccionario dos veces.
• Su setter no tiene que probar si el valor ya existe.

Public Shared Property DictionaryElement(ByVal Key As String) As Object
Get
Dim ret As String
If m_Dictionary.TryGetValue(Key, ret) Then Return ret
Return "" '' Same as String.Empty! ''
End Get
Set(ByVal value As Object)
m_Dictionary(Key) = value
End Set
End Property

Answer 2

Aquí hay una muestra para usted (con cambios según las sugerencias de Grauenwolf):

using System;
using System.Collections.Generic;
public class Test
{
public FakeIndexedPropertyInCSharp DictionaryElement { get; set; }
public Test()
{
DictionaryElement = new FakeIndexedPropertyInCSharp();
}
public class FakeIndexedPropertyInCSharp
{
private Dictionary<string, object> m_Dictionary = new Dictionary<string, object>();
public object this[string index]
{
get
{
object result;
return m_Dictionary.TryGetValue(index, out result) ? result : null;
}
set
{
m_Dictionary[index] = value;
}
}
}
}
class Program
{
static void Main(string[] args)
{
Test t = new Test();
t.DictionaryElement["hello"] = "world";
Console.WriteLine(t.DictionaryElement["hello"]);
}
}

Answer 3

Gracias Konrad, Alan, Grauenwolf,

En conclusión, no puedo usar las propiedades C # exactamente de la misma manera que en VB.NET ...: _ (De todos modos, sus respuestas me han sido muy útiles y probablemente llevaré estas ideas a mi código C #.

Además de las respuestas a la pregunta de propiedades, hay otros puntos buenos. Por ejemplo,

• Use TryGetValue, es más rápido. Usted consulta el diccionario dos veces.
• Su setter no tiene que probar si el valor ya existe.

Gracias Sören, también, usar un método no encaja bien en mis objetivos iniciales, pero muchas gracias.

Answer 4

La forma "correcta" de hacerlo en C # es crear clases para niños específicamente para acceder a la colección. Debe contener la colección en sí o tener enlaces internos a la clase principal.

Answer 5

La muestra de tu código me parece un diseño muy extraño y un abuso de a qué propiedades se destinan. ¿Por qué no solo un método de instancia AddOrUpdateKey ?

Public Sub AddOrUpdateKey(ByVal Key As String, ByVal Value as Object)
If m_Dictionary.ContainsKey(Key) Then
m_Dictionary(Key) = Value
Else
m_Dictionary.Add(Key, Value)
End If
End Sub

Su propiedad también devuelve String.Empty si la clave no existe, pero afirma que devuelve un Object , ni una String .

Answer 6

Una solución más general, más segura y reutilizable para su problema podría estar implementando una clase de propiedad genérica, "parametrizada", como esta:

 // Generic, parameterized (indexed) "property" template
public class Property<T>
{
// The internal property value
private T PropVal = default(T);
// The indexed property get/set accessor
// (Property<T>[index] = newvalue; value = Property<T>[index];)
public T this[object key]
{
get { return PropVal; } // Get the value
set { PropVal = value; } // Set the value
}
}

A continuación, puede implementar cualquier cantidad de propiedades dentro de su clase pública para que los clientes puedan establecer / obtener las propiedades con un índice, descriptor, clave de seguridad o lo que sea, de esta manera:

 public class ParameterizedProperties
{
// Parameterized properties
private Property<int> m_IntProp = new Property<int>();
private Property<string> m_StringProp = new Property<string>();
// Parameterized int property accessor for client access
// (ex: ParameterizedProperties.PublicIntProp[index])
public Property<int> PublicIntProp
{
get { return m_IntProp; }
}
// Parameterized string property accessor
// (ex: ParameterizedProperties.PublicStringProp[index])
public Property<string> PublicStringProp
{
get { return m_StringProp; }
}
}

Finalmente, el código del cliente accedería a las propiedades "parametrizadas" de su clase pública de esta manera:

 ParameterizedProperties parmProperties = new ParameterizedProperties();
parmProperties.PublicIntProp[1] = 100;
parmProperties.PublicStringProp[1] = "whatever";
int ival = parmProperties.PublicIntProp[1];
string strVal = parmProperties.PublicStringProp[1];

Claro, esto parece extraño, pero definitivamente es el truco. Además, desde una perspectiva de código de cliente, no es raro en absoluto, es simple e intuitiva y actúa como propiedades reales. No infringe ninguna regla C # ni es incompatible con otros lenguajes administrados .NET. Y desde la perspectiva del implementador de clases, la creación de una clase de plantilla de propiedades reutilizable, genérica y "parametrizada" hace que la codificación de componentes sea relativamente fácil, como se muestra aquí.

NOTA: siempre puede anular la clase de propiedad genérica para proporcionar un procesamiento personalizado, como la búsqueda indexada, el acceso a la propiedad controlado por seguridad o cualquier otra cosa que desee.

¡Aclamaciones!

Mark Jones