How to reduce noise in hardware design

Thanks.
I use below code for software filtering for interrupt inputs in my ISR and I have set interrupt for rising edge:

       void EXTI1_IRQHandler(void) //PA1
        {
          if(EXTI_GetITStatus(EXTI_Line1) != RESET)
         {
                                         delay_ms(100);
                                         if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1 )==1)
                                         {
                                         SYS.flag_pulse=1;
                                         SYS.flowtime=TIM_GetCounter(TIM2);
                                         TIM_SetCounter(TIM2,0);
                                         }
 /* Clear the EXTI line 1 pending bit */
EXTI_ClearITPendingBit(EXTI_Line1);
        }
        }

However even I use a 100ms delay again electric valve generates a pulse when opened or closed. I tried 1 sec delay but it seems it there is a problem with above code.

Waiting in an interrupt? Are you serious?

I modified the code and didn't use delay too in ISR.
In the following code I checked the earlier state and last state of the input pin to make sure it changes state.
now it works fine.

   void EXTI1_IRQHandler(void) //PA1
        {int i;
          if(EXTI_GetITStatus(EXTI_Line1) != RESET)
         {
            if (SYS.flag_pulse_low==1 && (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1 )==1))
                                         {
                                         SYS.flag_pulse=1;
                                         SYS.flowtime=TIM_GetCounter(TIM2);
                                         TIM_SetCounter(TIM2,0);
         /* Clear the EXTI line 1 pending bit */
          }
                                         EXTI_ClearITPendingBit(EXTI_Line1);
        }
        }

Delays in interrupt handles are no fun unless we are talking about a few NOP - such as when setting a number of digital outputs and then toggle a "latch" pin.

Often, it's enough to sample the pin value in the ISR to verify that it wasn't a single, almost infinitely short, pulse that trigged the interrupt. If more filtering is needed, then a timer can be used, so the pin interrupt handler starts a timer one or a couple of milliseconds later the processor gets a timer interrupt to make a second check of the pin state. It's even possible to let the timer produce a burst of multiple interrupts.

Another option is - if the processor supports it - to generate interrupts both for rising and falling pin and on the first pin interrupt start a timer. Each new pin change restarts the timer. If the timer finally manages to "ring" then you know the pin state has been stable for the full filter time (except for any pulse shorter than the detection logic for the pin interrupt hardware) A potential disadvantage with this method is that a high-frequency pulse train can result in a very large frequency of pin change interrupts which may consume all available CPU resources.

Any delays introduced in an ISR will not only lock up the main loop, but will also affect the servicing of other interrupts. And will break the task switching for programs that are using an RTOS. So a primary goal for an ISR is quick in/quick out.

Many thanks.