how cloud be support dynamically template for fixed buffers during compile time?

[sgf]

example:

public struct User 
{
 public fixed char name[30];
}

where i hope i can define I want to define a fixed-size string type like fllows:

public struct FixedString[int maxLen]
{
 public int Length;
 public byte charset;
 public fixed char Data[maxLen];
 public string ToString(){
  return new string(Data, startIndex, length);
 }
}

just look at the [int maxLen]
its a dynamically variable-sized structs (the sizeof(struct[?]) dynamically during compile time)
then i cound be define some fields of User like:

public struct User
{
 public FixedString[30] Name;
 public FixedString[50] Address;
}

ye,as u see,the FixedString is still could be when Compile has a fixed size.
we can use sizeof(User) and got size:
Size Of User=sizeof(FixedString[30])+sizeof(FixedString[50])=
sizeof(byte)+sizeof(fixed char Data[30])+
sizeof(byte)+sizeof(fixed char Data[50])=(4+1+60)+(4+1+100)=170

now we can get the Length and charset and read data from FixedString,and we dont need search the '\0'.from the old buffer.

What are the benefits of doing so:
We can save the strings of a fixed size structure.
then we can use pointer directly read and write it like:

ref T Read<T>() where T : unmanaged 
{
 ...//
}
Read<User>();

or

fixed(char* bp=srcbp){
User* ubp=(User*)bp;
User u=*ubp;
//...
}

or

var size=sizeof(User);//output 170

or

ref user=Read<User>();
user.Name.ToString();
user.Address.ToString();

[YairHalberstadt]

Hi
I'm sorry, but It's very difficult to understand your issue.
Am I right in thinking that English isn't your first language?
If so, please consider asking someone you know with better English to rewrite your Issue.
Thanks

[CyrusNajmabadi]

I believe @sgf is asking for dynamically variable-sized structs. i.e. he wants to allocate the memory for a struct (including a variable length part) all in one span, and then use it accordingly.

[Unknown6656]

If I understood the proposal correctly, @sgf does want a kind of integer-generics/templates in C# -- just like in C++.
e.g:

public readonly strcut Vector<int D>
{
	private readonly float[] _coefficients = new float[D];

	public int Dimension => D;

	// ....
}

public readonly strcut Matrix<int N, int M>
{
	// ....

	public (int Width, int Height) Dimensions => (N, M);

	public static Matrix<U, W> operator* (Matrix<U, V> m1, Matrix<V, W> m2) => ....;
}

Personally, I like integer generic parameters, however I think that we should be very careful on exactly how it is implemented and where the limitations currently reside...

[sgf]

@YairHalberstadt yes,right.english is not my first language.im sorry about my english.
@CyrusNajmabadi @Unknown6656 Their understanding is correct.

dynamically variable-sized structs base templates in compile-time.

that means,we can use sizeof() for it.
and we can use unsafe and pointer directly read and write it.

[ygc369]

@sgf
这种“编译时”的变长结构体价值不大，不如要求能在“创建时”指定其内部数组长度的结构体。

[sgf]

@ygc369
if support this feature.
thats will it is very convenient to make a serialization base fixed size struct.

@sgf
这种“编译时”的变长结构体价值不大，不如要求能在“创建时”指定其内部数组长度的结构体。

I don't know what you're talking about. What does it mean when you create a struct that specifies its internal length. My main hope here is that there is a mechanism to hold variable-length objects such as strings.

But I can limit the maximum length, but also can save the actual length and encoding and other meta-information.
I raised this question because I wanted to use a memory layout to make an RPC system that is compatible with both C + + and C # memory layouts. Fixed-size data structures such as Int32,int64 byte are resolved, but strings are relatively complex. In particular, string length issues.
The string in C is ending with '/0 ', but this requires a convenient lookup, which can have performance problems.
This RPC system contains redundancy by default However, I can compress it before sending it to solve the volume problem. I think that's a good idea because it allows C + + and C # to communicate seamlessly. There is no need to engage in something like protobuf those third-party descriptive languages.

不知道你说的创建时指定其内部长度的结构体是什么意思。
我这边主要希望可以 有一种机制用来保存 字符串这类 可变长度的对象。但是我可以限制最大长度，又可以保存实际长度和编码等元信息。

我之所以提出这个问题是因为我想利用内存布局做一个 同时兼容C++和C# 内存布局的 rpc系统。
int32,int64 byte 之类的固定大小的数据结构都好解决，但是string就相对复杂一些。尤其是字符串长度问题。按照C语言的字符串来说是以 '/0'结尾的，但是这样需要便利 查找，会有性能问题。
这个Rpc系统默认包含冗余 但是，我可以在发送前压缩一下，就可以解决体积问题。
我觉得这是一个很好的主意，因为这可以让C++和C# 无缝通信。不需要类似protobuf 那些第三方描述性语言之类的东西进行参与。

[ygc369]

@sgf
我说的“创建时”指定长度的结构体才算是真正跟C/C++语言里的变长结构体等价，其大小是在分配内存时指定的，可以是变量，而不是在编译时就能确定的。
比如C语言里可以这么写：

struct dynamic_string
{
    int length;
    char content[0];
};

void main()
{
    int len, i;
    struct dynamic_string *ds;
    scanf("%d", &len);
    ds = (struct dynamic_string *)malloc(sizeof(struct dynamic_string)+sizeof(char)*len);
    ds->length = len;
    for(i=0; i<len; i++) ds->content[i]='#';
    ......
}

如果C#里也有类似的机制就好了。

[sgf]

@ygc369
But the one you mentioned is no different from the string in C # 😂.
Or just throw a char[in C #] Array variables can also AH. The string itself is dynamic in length.
Char[] can also be assigned a new length. I was trying to solve the complex problem of serialization implementation because C + + has no reflection.

但是你提到的这个 和C#中的string的并无区别 😂。
或者直接 C#里面 丢一个char[] 数组变量也可以啊。
string本身就是动态长度的。char[] 也可以赋值新长度。

我是想解决 因为C++ 没有反射导致的序列化实现复杂的问题。

[ygc369]

@sgf
C#的string只是个特例而已，如果里面的数组不是char[]，而是int[]，不就没办法用string表示了么？况且string是不可变的，很多情况下不能满足需要。C#里的数组（比如char[], int[]等）是一个独立的对象，我想要的是把一个数组“内嵌”到其他对象里（即其他对象里直接保存数组的内容），而不是在其他对象里保存一个指向数组的引用。比如我希望定义如下对象：

class A
{
    int length;
    int data[?];
};

A a1 = new(10) A(); //data数组的长度是10
A a2 = new(20) A(); //data数组的长度是20
int n = Console.Read();
A a3 = new(n) A(); //data数组的长度是n

[sgf]

@ygc369

 struct A
    {
        public int length;
        public int[] data;
    };
 

            var a1 = new A();
            a1.data = new int[5];
            a1.length = 5;
            var a2 = new A();
            a2.data = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
            a2.length = a2.data.Length;

            Console.WriteLine(string.Join(',', a1.data));
            Console.WriteLine(string.Join(',', a2.data));

I have absolutely no idea what your intentions are. What you want, the above test program can be run. I don't know what the difference is with what you want.

我完全无法理解你的意图是什么？你要什么，上述测试程序可以运行。我不清楚和你要的有何区别。

另外 你的例子中 a1,a2,a3 是三种不同的变量，即3个对象，即使可变又有何意义？本身就是3个不同的对象了。
In addition, your example A1,A2,A3 is three different variables, that is, 3 objects, even if mutable and what is the point? is 3 different objects in itself.

class A
{
int length;
int data[?];
};

A a1 = new(10) A(); //data数组的长度是10
A a2 = new(20) A(); //data数组的长度是20
int n = Console.Read();
A a3 = new(n) A(); //data数组的长度是n

[khm1600]

@ygc369

比如C语言里可以这么写：

...

如果C#里也有类似的机制就好了。

You can do this in C# today:
C#现在就可以这么写：

    [StructLayout(LayoutKind.Sequential, Size = 6)]
    struct InlineString
    {
        public int length;
        public char fstChar;
    }

    unsafe
    {
        byte[] bytes = new byte[sizeof(InlineString) + sizeof(char) * 4];
        fixed (byte* b = bytes)
        {
            InlineString* str = (InlineString*)b;
            str->length = 5;
            for (int i = 0; i < 5; i++) (&str->fstChar)[i] = '#';
        }
    }