Вы не можете повысить разрешения процесса, когда процесс работает. Общий путь вокруг этого состоит в том, чтобы вызвать новый процесс с повышенными разрешениями при необходимости. Этот процесс затем выполняет работу, которая требует более высоких привилегий, а затем выходит, выделяя контроль обратно в основной процесс. Вы должны быть в состоянии сделать его довольно беспроводным, установив новых процессов родительского окна к окну главного процесса.

Другая альтернатива перезаправляется основной программой с необходимыми разрешениями.

Существует статья в UAC в Vista с примерами C ++ , которая выглядит довольно глубоко.

Это определяется в Спецификация языка Java, раздел 15.25.2 . Выделяемая часть:

Выражение составного назначения Форма E1 OP = E2 эквивалентна E1 = (T) ((e1) op (e2)), где t - тип E1, за исключением того, что E1 оценивается только один раз.

То есть в вашем случае разница является неявный тип ввода:

byte a = 100;
a += 1000;    // compiles
a = a + 1000; // doesn't compile, because an int cannot be assigned to a byte.

Нет никакой разницы, одно является кратким для другого. Даже компилятор будет генерировать одинаковые инструкции для обоих.

Изменить : компилятор НЕ генерирует один и тот же код для обоих, как я только что узнал. Посмотрите на это:

dan$ cat Test.java
public class Test {
    public static void main(String[] args) {
        int a = 0;
        a = a + 10;
        a += 20;
    }
}

dan$ javap -c Test
Compiled from "Test.java"
public class Test extends java.lang.Object{
public Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   bipush  10
   5:   iadd
   6:   istore_1
   7:   iinc    1, 20
   10:  return

}

Таким образом, короткий ответ, особенно для новичка Java или любого, кто не беспокоится об оптимизации на самом маленьком уровне, заключается в том, что они взаимозаменяемы. Длинный ответ будет зависеть от того, буду ли я читать о iadd vs iinc.

Изменить 2 : ОК, я вернулся. Инструкция specs (примерно):

iadd - добавляет две верхние точки в стеке

iinc - увеличивает локальную переменную на константу

И, как мы видели выше, мы можем сохранить пару команд с помощью iinc, если есть константа с правой стороны.

Но что будет, если у нас есть

a + = a ?

Тогда код выглядит так:

   7:   iload_1
   8:   iload_1
   9:   iadd
   10:  istore_1

что то же самое мы получаем, если у нас есть a = a + a .

Я вдохновился этим вопросом, чтобы попытаться выяснить, как такая глубокая проверка NULL может быть выполнена с помощью более простого/красивого синтаксиса с использованием деревьев выражений. Хотя я согласен с ответами, утверждающими, что это может быть плохой конструкцией, если вам часто нужно получить доступ к экземплярам глубоко в иерархии, я также считаю, что в некоторых случаях, таких как представление данных, это может быть очень полезно.

Поэтому я создал метод расширения, который позволит вам написать:

var berries = cake.IfNotNull(c => c.Frosting.Berries);

Это вернет ягоды, если ни одна часть выражения не имеет значения null. При обнаружении значения null возвращается значение null. Есть некоторые предостережения, хотя в текущей версии он будет работать только с простым доступом к членам, и он работает только на .NET Framework 4, поскольку использует метод MemberExpression.Update, который является новым в v4. Это код для метода расширения IfNotNull:

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace dr.IfNotNullOperator.PoC
{
    public static class ObjectExtensions
    {
        public static TResult IfNotNull<TArg,TResult>(this TArg arg, Expression<Func<TArg,TResult>> expression)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");

            if (ReferenceEquals(arg, null))
                return default(TResult);

            var stack = new Stack<MemberExpression>();
            var expr = expression.Body as MemberExpression;
            while(expr != null)
            {
                stack.Push(expr);
                expr = expr.Expression as MemberExpression;
            } 

            if (stack.Count == 0 || !(stack.Peek().Expression is ParameterExpression))
                throw new ApplicationException(String.Format("The expression '{0}' contains unsupported constructs.",
                                                             expression));

            object a = arg;
            while(stack.Count > 0)
            {
                expr = stack.Pop();
                var p = expr.Expression as ParameterExpression;
                if (p == null)
                {
                    p = Expression.Parameter(a.GetType(), "x");
                    expr = expr.Update(p);
                }
                var lambda = Expression.Lambda(expr, p);
                Delegate t = lambda.Compile();                
                a = t.DynamicInvoke(a);
                if (ReferenceEquals(a, null))
                    return default(TResult);
            }

            return (TResult)a;            
        }
    }
}

Он работает, проверяя дерево выражений, представляющее выражение, и вычисляя части один за другим; каждый раз проверяет, не имеет ли результат значение null.

Я уверен, что это можно расширить, чтобы поддерживать другие выражения, отличные от MemberExpression. Рассматривайте это как код, подтверждающий концепцию, и, пожалуйста, имейте в виду, что при его использовании будет штраф за производительность (который, вероятно, не будет иметь значения во многих случаях, но не используйте его в узком цикле: -))

В показанных выражениях они эквивалентны, в выражении, таком как

array[getIndex(context)][some / complex + expression] += offset;

, вы получаете представление, в каких ситуациях полезен оператор + = (и другие операторы назначения). Если выражение нетривиально, оператор + = предотвращает ошибки и улучшает читаемость и, следовательно, ремонтопригодность.

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

Правка : компилятор НЕ генерирует одинаковый код для обоих, как я только что узнал. Проверьте это:

dan$ cat Test.java
public class Test {
    public static void main(String[] args) {
        int a = 0;
        a = a + 10;
        a += 20;
    }
}

dan$ javap -c Test
Compiled from "Test.java"
public class Test extends java.lang.Object{
public Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   bipush  10
   5:   iadd
   6:   istore_1
   7:   iinc    1, 20
   10:  return

}

Итак, краткий ответ, особенно для новичков в Java или тех, кто не беспокоится об оптимизации на самом низком уровне, заключается в том, что они взаимозаменяемы. Длинный ответ будет зависеть от того, читаю ли я о iadd vs iinc.

Edit 2 : Хорошо, я вернулся. Спецификации инструкций (примерно) следующие:

iadd - добавляет два верхних целых числа в стек

iinc - увеличивает локальную переменную на константу

И, как мы видели выше, мы можем сохранить пару инструкций с помощью iinc, если с правой стороны есть константа.

Но что произойдет, если мы имеем

a + = a ?

Тогда код будет выглядеть так:

   7:   iload_1
   8:   iload_1
   9:   iadd
   10:  istore_1

то же самое, что мы получим, если имеем a = a + a .