C＃中是否存在类似代码同义词的内容？

Question

For example i have some code:

if (myArray[i, j, k] == someValue)
  myArray[i, j, k] = someOtherValue;
else
  throw new Exception(string.Format("value {0} is wrong!", myArray[i, j, k]));

and it seems that it is a bit dangerous. I would like to had some "code synonym", like that:

var xx => myArray[i, j, k];
if (xx == someValue)
  xx = someOtherValue;
else
  throw new Exception(string.Format("value {0} is wrong!", xx));

where xx isn't a value of myArray[i, j, k] , but a synonym to that code, and => is some kind of declaration syntax for this construct.

I'd like to have this feature to ensure that multiply myArray[i, j, k] usage would be exactly the same code, without risk of getting myArray[j, i, k] in some place.

May be C# can do something like that, without ugly syntax? I mean safe code, not unsafe memory pointer. Or maybe something is wrong with my point of viewh?

---

I apologize for possibly incorrect definition of my idea. I'd like to use this trick ("code synonyms" or something like that) as regular feature of language(? or compiler etc), not only in this single case. Specialized classes or functions are good in particular case, but in general they will lead to a significant increase in the amount of code, and i would like to avoid this.

Answer 1

May be use some function for this? For example:

In your code:

UpdateElement(ref myArray[i, j, k], someValue, someOtherValue);

And function:

void UpdateElement(ref int element, int compareWith, int value)
{
     if (element == compareWith)
         element = value;
     else
         throw new Exception(string.Format("Value {0} is wrong!", element));
}

UPD: Method renaming from 'TryUpdateElement' to 'UpdateElement', because of Try.. methods usually don't throw exceptions.

Answer 2

You could implement your own matrix type that would store an actual index

public class Matrix<T>
{
    private T[, ,] _array;

    public Matrix(int sizeX, int sizeY, int sizeZ)
    {
        _array = new T[sizeX, sizeY, sizeZ];
    }

    public T this[int i, int j, int k]
    {
        get { return _array[i, j, k]; }
        set { _array[i, j, k] = value; }
    }

    public int CurrentI { get; set; }
    public int CurrentJ { get; set; }
    public int CurrentK { get; set; }

    public void SetCurrentCell(int i, int j, int k)
    {
        CurrentI = i;
        CurrentJ = j;
        CurrentK = k;
    }

    public T Current
    {
        get { return _array[CurrentI, CurrentJ, CurrentK]; }
        set { _array[CurrentI, CurrentJ, CurrentK] = value; }
    }

    public static implicit operator T(Matrix<T> matrix)
    {
        return matrix.Current;
    }

    // The assignment operator (=) cannot be overloaded. But we can overload |
    // instead, allowing us to write: m |= value in order to perform an assignment.
    public static Matrix<T> operator |(Matrix<T> m, T value)
    {
        m.Current = value;
        return m;
    }
}

You can use it like this:

var m = new Matrix<int>(3, 3, 3);
m[0, 2, 1] = 77;
m.SetCurrentCell(0, 2, 1);
m.Current = 88;
int value = m; // Using the implicit operator and the current indexes
m |= 20; // Using |= as assignment operator

---

The generic approach has the disadvantage that it becomes more difficult to implement numeric operations (mathematical operations like +, -, *, / are not defined on generic types). But you could resolve the generic type in a dervied class, that implements numeric calculations

public class DoubleMatrix : Matrix<double> {
    public static DoubleMatrix operator +(DoubleMatrix a, DoubleMatrix b)
    {
        //TODO: Implement + operator
        return m;
    }

    //TODO: Implement other operators
}

---

C# 7.0 introduced ref locals allowing you to do just that

ref int xx = ref myArray[i, j, k];
if (xx == someValue)
    xx = someOtherValue;
else
    throw new Exception(string.Format("value {0} is wrong!", xx));

Note that you get not only a synonym but a reference, which means that the array indexes get evaluated only once.

Answer 3

You can use anonymous delegates for this.

var get_xx = delegate(){ return myArray[i, j, k];};
var set_xx = delegate(int v){ myArray[i, j, k] = v;};

if (get_xx() == someValue)
  set_xx(someOtherValue);
else
  throw new Exception(string.Format("value {0} is wrong!", get_xx()));

Answer 4

That last sentence is calling for obvious responses. It seems you'd like to use something like a code generator.

Something like a C preprocessor would appear to fit the bill:

#define xx myArray[i, j, k]

Well, that is indeed not the ... usual "point of view", but the good news is, you can simply use the CPP preprocessor in your C# project.

Ideas:

• Make it a prebuild step.
• generate your .cs from a .cs.cpp file

Answer 5

You could write yourself a function that allows you to do something like this:

UpdateMatrixValueIf(myArray, i, j, k, (v) => v == someValue, someOtherValue);

And implement it like this:

public void UpdateMatrixValueIf<T>(T[,,] array, int i, int j, int k, Func<T, bool> check, T newValue)
{
    if (check(array[i, j, k]))
        array[i, j, k] = newValue;
    else
        throw new Exception(string.Format("Value {0} is wrong!", array[i, j, k]));
}

Of course doing something like this only really makes sense, if you do it more than once. Otherwise the answer is simply no, that you can't do it in a better or safer way. You could make use of some crazy reflection methods, but I don't think that would be appropriate here. Just make sure such a code section is unit tested, and you shouldn't end up with index issues.