Форум программистов, компьютерный форум, киберфорум
Java
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.89/9: Рейтинг темы: голосов - 9, средняя оценка - 4.89
-12 / 3 / 0
Регистрация: 02.04.2012
Сообщений: 347
1

Сохранить/вывести тип в рантайме

08.07.2020, 22:52. Просмотров 1810. Ответов 1
Метки нет (Все метки)

Добрый день.

Есть такая штука:
Java
1
2
import com.google.gson.reflect.TypeToken;
new TypeToken<T>(){}.getType();
Она позволяет сохранять тип и использовать в рефлексии.

Нужно написать такой метод, который на вход получает тип OurType и выдает Type = WrappedType<OurType>. То есть такой метод
Java
1
[INLINE]public static <T> T castToClass(Class<T> cls);[/INLINE]
____________________________________________________________ _________________


Теперь опишу ситуацию, в которой пришел к этой необходимости.

Есть такая штука - GSON. Либа умеет превращать строку-json в объект заданного класса:
Java
1
MyClass mc = new Gson.fromJson(json, MyClass.class);
Очень удобно... Когда ты заранее знаешь, что за тип ты получаешь.

Если же ты хочешь написать параметризованный метод, который возвращает значение в зависимости от переданного типа, то получается обломный облом.
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Type1 {
    public Integer f11;
    public Type2 f12;
 
    public class Type2 {
        public String f21;
        public Integer f22;
    }
}
 
public static <T> castToClass(Class<T> cls){
    // здесь очень сложный код по получению исходного json.
    String json = varyHardMethod();
    
    return new Gson.fromJson(json, new TypeToken<T>(){}.getType());
}
 
// не работает, тип "размывается" и получаем ошибку
System.out.println(castToClass(Type1.class).f12.f22);
На выходе получаем ошибку Exception in thread "main" java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to solution.test.Type1.

Ситуация усугубляется, когда мне надо получить не T, а WrappedType<T>.
Java
1
2
3
4
5
6
public static <T> T castToClass(Class<T> cls){
    // здесь очень сложный код по получению исходного json.
    String json = varyHardMethod();
    
    return new Gson().fromJson(json, new TypeToken<WrappedType<T>>(){}.getType());
}
Ситуация решается вот так:
Java
1
2
3
4
5
6
7
8
public static <T> T castToClass(TypeToken<WrappedType<T>> gsonType){
    // здесь очень сложный код по получению исходного json.
    String json = varyHardMethod();
    
    return new Gson().fromJson(json, gsonType.getType());
}
 
System.out.println(castToClass(new TypeToken<Type1>(){}).f12.f22);
Но у нас получается некрасивый внешний интерфейс. И желание избавится от некрасивости и сделать все красиво, привело меня сюда.
Подскажите, пожалуйста, неужели нет способа "скормить" методу красивое значение "выходной тип данных" и получить на выходе рабочий результат?
Код уже работает, но хочется, чтобы он был красивым.
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
08.07.2020, 22:52
Ответы с готовыми решениями:

Не могу сохранить тип Text
Пытаюсь сохранить тип Text, но что-то пошло не так. using System.Collections; using...

передать и сохранить тип класа
Всем привет. У меня есть клас (пример ниже) в котором есть функция шаблон принимающая тип (имя)...

Можно ли сохранить тип object в приложении?
Добрый день. Можно ли сохранить тип object в приложении (в Properties.Settings) ? Если можно,...

Возможно ли сохранить в файл тип класса?
Доброго времени, господа программеры! Как бы яснее пояснить чего я хочу добится? Значит есть в...

1
49 / 24 / 8
Регистрация: 04.05.2013
Сообщений: 65
10.07.2020, 14:25 2
Совсем красиво не получится. Иерархию типов где-нибудь да придётся указать.

Давно решал похожую, но более сложную задачу написания удаленного вызова процедур для обобщенных методов. Кусок кода ответственный за хранение типа и корректное восстановление.

Кликните здесь для просмотра всего текста

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
public class GenericType {
    @JsonIgnore
    protected static final Map<String, Class<?>> primitives = new HashMap<>();
    @JsonIgnore
    protected static final Map<Class<?>, Function<String, ?>> primitivesParser = new HashMap<>();
 
    static {
        primitives.put(boolean.class.getName(), boolean.class);
        primitivesParser.put(boolean.class, Boolean::parseBoolean);
 
        primitives.put(byte.class.getName(), byte.class);
        primitivesParser.put(byte.class, Byte::parseByte);
 
        primitives.put(short.class.getName(), short.class);
        primitivesParser.put(short.class, Short::parseShort);
 
        primitives.put(int.class.getName(), int.class);
        primitivesParser.put(int.class, Integer::parseInt);
 
        primitives.put(char.class.getName(), char.class);
        primitivesParser.put(char.class, src -> src.trim().charAt(0));
 
        primitives.put(long.class.getName(), long.class);
        primitivesParser.put(long.class, Long::parseLong);
 
        primitives.put(float.class.getName(), float.class);
        primitivesParser.put(float.class, Float::parseFloat);
 
        primitives.put(double.class.getName(), double.class);
        primitivesParser.put(double.class, Double::parseDouble);
 
        primitives.put(void.class.getName(), void.class);
        primitivesParser.put(void.class, src -> null);
    }
 
    @JsonIgnore
    protected Class<?> clazz;
    protected String className;
    protected boolean isLiteral;
    protected WildcardType wildcard;
    protected GenericType[] generics;
 
    protected List<String> genericLiterals;
 
    /**
    * Имя переменной, которая имеет данный тип.
    */
    protected String name;
 
    public GenericType() {
        setClazz(null);
        setClassName(null);
        isLiteral(false);
        setWildcard(null);
        setGenerics(null);
        setGenericLiterals(new ArrayList<>());
    }
 
    public GenericType(Class<?> clazz, GenericType... generics) {
        setClazz(clazz);
        if (clazz != null)
            setClassName(clazz.getName());
        else
            setClassName(null);
        isLiteral(false);
        setWildcard(null);
        setGenerics(generics);
        setGenericLiterals(new ArrayList<>());
    }
 
    public GenericType(String literal, WildcardType wildcard, GenericType... generics) {
        setClazz(null);
        isLiteral(true);
        setClassName(literal);
        setWildcard(wildcard);
        setGenerics(generics);
        setGenericLiterals(new ArrayList<>());
    }
 
    public Class<?> getClazz() {
        return clazz;
    }
    protected void setClazz(Class<?> clazz) {
        this.clazz = clazz;
    }
    protected GenericType withClazz(Class<?> clazz) {
        setClazz(clazz);
        return this;
    }
 
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
        if ((className != null) & !isLiteral) {
            try {
                if (primitives.containsKey(className))
                    setClazz(primitives.get(className));
                else
                    setClazz(Class.forName(className));
            } catch (ClassNotFoundException e) {}
        }
    }
    public GenericType withClassName(String className) {
        setClassName(className);
        return this;
    }
 
    @JsonGetter("isLiteral")
    public boolean isLiteral() {
        return isLiteral;
    }
    @JsonSetter("isLiteral")
    public void isLiteral(boolean isLiteral) {
        this.isLiteral = isLiteral;
    }
    public GenericType withIsLiteral(boolean isLiteral) {
        isLiteral(isLiteral);
        return this;
    }
 
    public WildcardType getWildcard() {
        return wildcard;
    }
    public void setWildcard(WildcardType wildcard) {
        if (wildcard == null)
            this.wildcard = WildcardType.NONE;
        else
            this.wildcard = wildcard;
    }
    public GenericType withWildcard(WildcardType wildcard) {
        setWildcard(wildcard);
        return this;
    }
 
    @JsonIgnore
    public int getGenericsCount() {
        if ((generics == null) || (generics.length == 0))
            return 0;
        else
            return generics.length;
    }
 
    public GenericType[] getGenerics() {
        return generics;
    }
    public void setGenerics(GenericType[] generics) {
        this.generics = generics == null ? new GenericType[0] : generics;
    }
    public GenericType withGenerics(GenericType[] generics) {
        setGenerics(generics);
        return this;
    }
 
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public GenericType withName(String name) {
        setName(name);
        return this;
    }
 
    public List<String> getGenericLiterals() {
        return genericLiterals;
    }
    public void setGenericLiterals(List<String> genericLiterals) {
        this.genericLiterals = genericLiterals;
    }
    public GenericType withGenericLiterals(List<String> genericLiterals) {
        setGenericLiterals(genericLiterals);
        return this;
    }
 
    @JsonIgnore
    public boolean isPrimitive() {
        return (getGenericsCount() == 0) && primitives.containsValue(clazz);
    }
    @JsonIgnore
    public Object parsePrimitive(String src) {
        return primitivesParser.get(clazz).apply(src);
    }
    
    @Override
    public String toString() {
        if (getGenericsCount() == 0)
            if (clazz != null)
                return clazz.getSimpleName();
            else
                return className;
        else if (getGenericsCount() == 1)
            return String.format("%s<%s>", clazz.getSimpleName(), generics[0].toString());
        else if (getGenericsCount() == 2)
            return String.format("%s<%s, %s>", clazz.getSimpleName(), generics[0].toString(), generics[1].toString());
        else {
            StringBuilder sb = new StringBuilder();
            sb.append(clazz.toString());
            sb.append("<");
            for (GenericType type : generics) {
                sb.append(type.toString());
                sb.append(", ");
            }
            sb.delete(sb.length()-2, sb.length());
            sb.append(">");
            return sb.toString();
        }
    }
 
    @Override
    public int hashCode() {
        return (int) ((className != null ? className.hashCode() : 0) + ((long) getGenericsCount() << 32));
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if ((obj == null) || !getClass().equals(obj.getClass()))
            return false;
        GenericType oth = (GenericType) obj;
        return className.equals(oth.className) && (getGenericsCount() == oth.getGenericsCount()) && listCompare(generics, oth.generics);
    }
 
    protected static boolean listCompare(GenericType[] list1, GenericType[] list2) {
        boolean fault = false;
        for (int i = 0; !fault && (i < list1.length); i++)
            fault = !list1[i].equals(list2[i]);
        return !fault;
    }
 
}
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
@JsonPropertyOrder(value = { "type", "value", "null" })
@JsonDeserialize(using = GenericValueDeserilizator.class)
public class GenericValue {
    
    public static GenericValue NULL() {
        GenericValue value = new GenericValue();
        value.setNull(true);
        return value;
    }
 
    private Object value;
    private GenericType type;
    private boolean isNull;
 
    public GenericValue() {
        setValue(null);
        setType(null);
        setNull(false);
    }
    public GenericValue(Object value, GenericType type) {
        setValue(value);
        setType(type);
        setNull(false);
    }
 
    public <T> GenericValue(T value, Class<T> clazz) {
        setValue(value);
        setType(new GenericType(clazz));
    }
 
    public Object getValue() {
        return value;
    }
 
    @SuppressWarnings({"unchecked", "unused"})
    public <T> T getValue(Class<T> clazz) {
        return (T) value;
    }
    @SuppressWarnings({"unchecked", "unused"})
    public <T> T getValue(Class<T> clazz, T defaultValue) {
        try {
            return (T) value;
        } catch (Exception e) {
            return defaultValue;
        }
    }
    @SuppressWarnings({"unchecked", "unused"})
    public <T, V> T getValue(Class<T> clazz, Class<V> srcClazz, Function<V, T> converter) {
        return converter.apply((V) value);
    }
    @SuppressWarnings({"unchecked", "unused"})
    public <T, V> T getValue(Class<T> clazz, Class<V> srcClazz, Function<V, T> converter, T defaultValue) {
        try {
            return converter.apply((V) value);
        } catch (Exception e) {
            return defaultValue;
        }
    }
    @SuppressWarnings({"unchecked", "unused"})
    public <T> T getValue(Class<T> clazz, Function<String, T> converter, T defaultValue) {
        try {
            return converter.apply((String) value);
        } catch (Exception e) {
            return defaultValue;
        }
    }
    public <T> T getValue(TypedValue<T> type, T defaultValue) {
        Objects.requireNonNull(type, "Не задан тип.");
        return type.value(value, defaultValue);
    }
 
    public void setValue(Object value) {
        this.value = value;
    }
 
    public GenericType getType() {
        return type;
    }
    public void setType(GenericType type) {
        this.type = type;
    }
 
    public boolean isNull() {
        return isNull;
    }
    public void setNull(boolean aNull) {
        isNull = aNull;
    }
 
    @Override
    public int hashCode() {
        return value != null ? value.hashCode() : 0;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (obj == null || !obj.getClass().equals(GenericValue.class))
            return false;
        GenericValue other = (GenericValue) obj;
        if ((other.type != null) && (type != null)) {
            if (!other.type.equals(type))
                return false;
        } else if ((other.type == null) && (type != null))
            return false;
        else if (other.type != null)
            return false;
 
        if (other.value != null && value == null)
            return false;
        else if ((other.value == null) && (value != null))
            return false;
        else if (other.value == null)
            return true;
        else
            return other.value.equals(this.value);
    }
 
    @Override
    public String toString() {
        return String.format("GenericValue(value=%s, type=%s)", value, type);
    }
 
    public static GenericValue valueOfString(String value) {
        return new GenericValue(value, new GenericType(String.class));
    }
 
    public static GenericValue valueOfLong(long value) {
        return new GenericValue(value, new GenericType(long.class));
    }
 
    public static GenericValue valueOfInt(int value) {
        return new GenericValue(value, new GenericType(int.class));
    }
 
}
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
public class GenericValueDeserilizator extends JsonDeserializer<GenericValue> {
                
    private static final Logger LOG = LogManager.getLogger(GenericValueDeserilizator.class);
    
    private static final List<Class<?>> primitivies = Arrays.asList(
        byte.class,
        short.class,
        char.class,
        int.class,
        long.class,
        float.class,
        double.class,
        boolean.class
    );
    
    @Override
    public GenericValue deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        GenericValue result = new GenericValue();
        Integer ind = (Integer) ctxt.getAttribute("methodNum");
 
        p.nextToken();
        try {
            // Первым параметром всегда идет type, а только затем value как указано в @JsonPropertyOrder при GenericValue.
            p.nextToken();
            p.getText(); // Название поля "type"
            result.setType(ctxt.readValue(p, GenericType.class));
            
            p.nextToken();
            p.getText(); // Название поля "value"
            result.setValue(JsonSerializator.retakeJsonFromTokenStream(p)); // Читать объект их потока не возможно, не зная null ли это
 
            p.nextToken();
            p.getText();
            p.nextToken();
            result.setNull(ctxt.readValue(p, boolean.class));
            
            p.nextToken();
            
            if (result.getType() != null) {
                boolean isClass = false;
                boolean isPrimitive = false;
                boolean isNull = false;
                
                // Проверка на примитивный тип, класс или null
                if (result.getType().isLiteral() || result.getType().getClazz().equals(Class.class))
                    isClass = true;
                else if (primitivies.contains(result.getType().getClazz()))
                    isPrimitive = true;
                if (!isPrimitive) // Примитив по-умолчанию не null
                    isNull = ((String) result.getValue()).trim().toLowerCase().equals("null");
 
                if (isNull || result.getType().getClassName().equals("void"))
                    result.setValue(null);
 
                MethodDescriptor md = ((MethodDescriptor) ctxt.getAttribute(MethodDescriptor.class));
 
                if (result.getType().isLiteral() && !isNull) {
                    Class type = (Class) ctxt.getAttribute(result.getType().getClassName());
                    result.setValue(JsonSerializator.deserialize((String) result.getValue(), type));
                } else if (isClass) {
                    String clazz = (String) result.getValue();
                    if (clazz != null) {
                        clazz = clazz.substring(clazz.startsWith("\"") ? 1 : 0, clazz.endsWith("\"") ? clazz.length() - 1 : clazz.length());
                        result.setValue(Class.forName(clazz));
                    } else
                        clazz = "java.lang.Object";
 
                    // Проверяем, является ли это класс определяющим для дженерика метода
                    // Если да, то сохраняем в контексте разбора определение литерала дженерика: T -> Class<T>
                    if (ind < md.getArguments().size()) {
                        GenericType method = md.getArguments().get(ind);
                        if (method.getClassName().equals("java.lang.Class") && (method.getGenericsCount() == 1) && (method.getGenerics()[0].isLiteral()))
                                        ctxt.setAttribute(method.getGenerics()[0].getClassName(), result.getValue());
                    } else {
                        result.getType().setClazz((Class) ctxt.getAttribute(result.getType().getClassName()));
                    }
                } else // Обобщенный случай
                    if (result.getValue() != null)
                        result.setValue(JsonSerializator.deserialize((String) result.getValue(), JsonSerializator.getType(result.getType(), ctxt)));
            } else // Тип не задан, считаем null
                result.setValue(JsonSerializator.deserialize((String) result.getValue(), Object.class));
        } catch (Exception e) {
            LOG.error("", e);
        } finally {
            if (ind != null)
                    ctxt.setAttribute("methodNum", ind + 1);
        }
        return result;
    }
 
}
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
public class JsonSerializator  {
    
    private static final Logger LOG = LogManager.getLogger(JsonSerializator.class);
 
    private static final ObjectMapper mapper;
    protected static final JsonFactory factory;
 
    static {
        mapper = new ObjectMapper();
        factory = new JsonFactory();
        mapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, true);
        // FIXME: for debuging
        mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
    }
 
    public static <T> String serialize(T message) {
        try {
            return mapper.writeValueAsString(message);
        } catch (JsonProcessingException e) {
            LOG.error("", e);
            return null;
        }
    }
 
    public static <T> T deserialize(String message, Class<T> clazz) {
        try {
            return mapper.readValue(message, clazz);
        } catch (IOException e) {
            LOG.error("", e);
            return null;
        }
    }
    public static Object deserialize(String message, JavaType javaType) {
        try {
            return mapper.readValue(message, javaType);
        } catch (IOException e) {
            LOG.error("", e);
            return null;
        }
    }
    
    public static JavaType getType(GenericType genericType, DeserializationContext ctxt) {
        if (genericType.isLiteral()) {
            Class clazz = (Class) ctxt.getAttribute(genericType.getClassName());
            if (clazz != null)
                return TypeFactory.defaultInstance().uncheckedSimpleType(clazz);
            else
                return TypeFactory.defaultInstance().uncheckedSimpleType(Object.class);
        }
        JavaType[] refTypes = new JavaType[genericType.getGenericsCount()];
        for (int i = 0; i < refTypes.length; i++)
            refTypes[i] = getType(genericType.getGenerics()[i], ctxt);
        return TypeFactory.defaultInstance().constructParametricType(genericType.getClazz(), refTypes);
    }
    
    /**
     * Преобразование токенов обратно в строку.
     * 
     * @param p парсер с токенами
     */
    public static String retakeJsonFromTokenStream(JsonParser p) throws IOException {
        RedirectOutputStream stream = new RedirectOutputStream();
        JsonGenerator g = factory.createGenerator(stream);
 
        int c = 1;
        boolean isPrim = false;
        int braces = 0;
        JsonToken token = p.nextToken();
        while (token != null) {
            switch (token) {
                case START_OBJECT:
                    g.writeStartObject();
                    p.getText();
                    braces++;
                    break;
                case START_ARRAY:
                    g.writeStartArray();
                    p.getText();
                    braces++;
                    break;
                case END_ARRAY:
                    g.writeEndArray();
                    p.getText();
                    braces--;
                    if (braces == 0)
                        token = null;
                    break;
                case END_OBJECT:
                    g.writeEndObject();
                    p.getText();
                    braces--;
                    if (braces == 0)
                        token = null;
                    break;
                case FIELD_NAME:
                    g.writeFieldName(p.getText());
                    break;
                case VALUE_TRUE:
                    g.writeBoolean(p.getBooleanValue());
                    if (c == 1)
                        isPrim = true;
                    break;
                case VALUE_FALSE:
                    g.writeBoolean(p.getBooleanValue());
                    if (c == 1)
                        isPrim = true;
                    break;
                case VALUE_NULL:
                    g.writeNull();
                    p.getText();
                    if (c == 1)
                        isPrim = true;
                    break;
                case VALUE_NUMBER_FLOAT:
                    g.writeNumber(p.getDoubleValue());
                    if (c == 1)
                        isPrim = true;
                    break;
                case VALUE_NUMBER_INT:
                    g.writeNumber(p.getLongValue());
                    if (c == 1)
                        isPrim = true;
                    break;
                case VALUE_STRING:
                    g.writeString(p.getText());
                    if (c == 1)
                        isPrim = true;
                    break;
                default:
            }
            c++;
            if (isPrim)
                token = null;
            if (token != null)
                token = p.nextToken();
        }
        g.close();
        return stream.asString();
    }
 
}
Java
1
2
3
public enum WildcardType {
    NONE, EXTEND, SUPER;
}


Пример использования:

Java
1
2
Map<String, List<Integer>> map = new HashMap<>();
new GenericValue(map, new GenericType(Map.class, new GenericType(String.class), new GenericType(List.class, new GenericType(int.class)))
1
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
10.07.2020, 14:25

Заказываю контрольные, курсовые, дипломные и любые другие студенческие работы здесь.

Задать тип данных, содержащий два поля: Фамилия, Возраст. Последовательно ввести данные на трех человек и сохранить их в файле
Задать тип данных, содержащий два поля: Фамилия (строковый), Возраст (целочисленный)....

Как сохранить "тип" структуры в переменной
существует такая шняга: Read&lt;Int64&gt;(dwAddress) вот мне хотелось бы узнать, как менять Int64 на...

Как в поле таблицы сохранить файл документ какой тип данных должен быть и как преобразовать на C#
Необходимо сохранить файл в базу данных на C# ПОдскажите как это сделать)) Заранее спасибо!!!

Реализовать внешнюю функцию с именем make _ тип (), где тип — тип реализуемой структуры
Реализовать внешнюю функцию с именем make _ тип (), где тип — тип реализуемой структуры. Функция...

Присваивание событий в рантайме
Имеется ToolStripMenuItem. Из него в рантайме нужно создать ToolStripButton. В том числе и событие...

Создание элементов в рантайме
Возможно ли, допустим, при нажатии на кнопку создать (не показать visible), а именно создать новый...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
2
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2021, vBulletin Solutions, Inc.